from matplotlib import image as mpimg
import matplotlib.pyplot as plt
import numpy as np
import cv2

# Load images
try:
    img1 = mpimg.imread('data/img1.jpg')
    img2 = mpimg.imread('data/img2.jpg')
    img3 = mpimg.imread('data/img3.jpg')
    img10 = mpimg.imread('data/img10.jpg')
    print('Images loaded successfully!')
    print('Image 1 shape:', img1.shape)
    print('Image 2 shape:', img2.shape)
    print('Image 3 shape:', img3.shape)
    print('Image 10 shape:', img10.shape)
except FileNotFoundError as e:
    print(f"Error loading images: {e}. Please ensure the 'data' folder is in the same directory as this notebook and contains the required images.")
    # Handle gracefully if images are not found
    img1, img2, img3, img10 = None, None, None, None

Images loaded successfully!
Image 1 shape: (3464, 4618, 3)
Image 2 shape: (3024, 4032, 3)
Image 3 shape: (4032, 3024, 3)
Image 10 shape: (256, 256, 3)

# Display the selected images
if img1 is not None and img2 is not None and img3 is not None:
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))

    axes[0].imshow(img1)
    axes[0].set_title('Image 1')
    axes[0].axis('off')

    axes[1].imshow(img2)
    axes[1].set_title('Image 2')
    axes[1].axis('off')

    axes[2].imshow(img3)
    axes[2].set_title('Image 3')
    axes[2].axis('off')

    plt.tight_layout()
    plt.show()

# Creating our CLAHE function. Receives an image, a clip limit and a tile grid size.
def apply_clahe(image, clip_limit=2.0, tile_grid_size=(8, 8)):
    """
    Applies Contrast-Limited Adaptive Histogram Equalization (CLAHE).

    Parameters:
    - image: The input grayscale image.
    - clip_limit: The contrast clipping threshold. A higher value means more contrast.
    - tile_grid_size: The size of the tile grid (width, height).

    Returns:
    - The processed image.
    """
    # Create a CLAHE object
    clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)

    # Apply CLAHE to the image
    processed_image = clahe.apply(image)

    return processed_image

if img1 is not None and img2 is not None and img3 is not None:
    try:
        # Convert images to grayscale for CLAHE processing
        img1_gray = cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY)
        img2_gray = cv2.cvtColor(img2, cv2.COLOR_RGB2GRAY)
        img3_gray = cv2.cvtColor(img3, cv2.COLOR_RGB2GRAY)
        
        # Vary the window size and contrast limits for testing
        sizes = [(4, 4), (8, 8), (16, 16)]
        clip_limits = [1.0, 2.0, 4.0]
        
        images = [img1_gray, img2_gray, img3_gray]
        image_names = ['Image 1', 'Image 2', 'Image 3']
        
        for img_idx, (img_gray, img_name) in enumerate(zip(images, image_names)):
            print(f"\nProcessing {img_name}...")
            
            # Create a comprehensive figure with images and histograms
            fig = plt.figure(figsize=(20, 25))
            
            # Create grid layout: 2 columns (image + histogram) for each row
            gs = fig.add_gridspec(len(sizes) * len(clip_limits) + 1, 2, hspace=0.3, wspace=0.3)
            
            # Original image and histogram
            ax_img = fig.add_subplot(gs[0, 0])
            ax_hist = fig.add_subplot(gs[0, 1])
            
            ax_img.imshow(img_gray, cmap='gray')
            ax_img.set_title(f"{img_name} - Original (Grayscale)", fontsize=14, fontweight='bold')
            ax_img.axis('off')
            
            # Original histogram
            ax_hist.hist(img_gray.ravel(), bins=256, range=(0, 255), color='gray', alpha=0.7)
            ax_hist.set_title(f"Original Histogram", fontsize=12)
            ax_hist.set_xlabel('Pixel Intensity')
            ax_hist.set_ylabel('Frequency')
            ax_hist.grid(True, alpha=0.3)
            
            plot_index = 1
            
            for size in sizes:
                for clip in clip_limits:
                    processed_image = apply_clahe(img_gray, clip_limit=clip, tile_grid_size=size)
                    
                    # Image subplot
                    ax_img = fig.add_subplot(gs[plot_index, 0])
                    ax_img.imshow(processed_image, cmap='gray')
                    ax_img.set_title(f"CLAHE: Tile {size}, Clip {clip}", fontsize=12)
                    ax_img.axis('off')
                    
                    # Histogram subplot
                    ax_hist = fig.add_subplot(gs[plot_index, 1])
                    ax_hist.hist(processed_image.ravel(), bins=256, range=(0, 255), color='blue', alpha=0.7)
                    ax_hist.set_title(f"Histogram: Tile {size}, Clip {clip}", fontsize=12)
                    ax_hist.set_xlabel('Pixel Intensity')
                    ax_hist.set_ylabel('Frequency')
                    ax_hist.grid(True, alpha=0.3)
                    
                    plot_index += 1
            
            plt.suptitle(f"CLAHE Analysis for {img_name}", fontsize=16, fontweight='bold', y=0.98)
            plt.tight_layout()
            plt.show()
            
            # Statistical analysis
            print(f"\n{img_name} - Statistical Analysis:")
            print(f"Original - Mean: {img_gray.mean():.2f}, Std: {img_gray.std():.2f}")
            
            # Test different parameters and show best results
            best_contrast = 0
            best_params = None
            best_image = None
            
            for size in sizes:
                for clip in clip_limits:
                    test_img = apply_clahe(img_gray, clip_limit=clip, tile_grid_size=size)
                    contrast = test_img.std()  # Standard deviation as contrast measure
                    if contrast > best_contrast:
                        best_contrast = contrast
                        best_params = (size, clip)
                        best_image = test_img
            
            print(f"Best CLAHE - Tile: {best_params[0]}, Clip: {best_params[1]}")
            print(f"Best CLAHE - Mean: {best_image.mean():.2f}, Std: {best_image.std():.2f}")
            print(f"Contrast Improvement: {((best_contrast - img_gray.std()) / img_gray.std() * 100):.1f}%")

    except Exception as e:
        print(f"An unexpected error occurred: {e}")

Processing Image 1...

/var/folders/fc/52j9sv_132gdd2pvx3lpbt180000gn/T/ipykernel_19281/3437559743.py:62: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.
  plt.tight_layout()

Image 1 - Statistical Analysis:
Original - Mean: 110.41, Std: 62.25
Best CLAHE - Tile: (4, 4), Clip: 2.0
Best CLAHE - Mean: 123.45, Std: 71.19
Contrast Improvement: 14.4%

Processing Image 2...

Image 2 - Statistical Analysis:
Original - Mean: 82.35, Std: 41.08
Best CLAHE - Tile: (4, 4), Clip: 4.0
Best CLAHE - Mean: 121.63, Std: 63.24
Contrast Improvement: 53.9%

Processing Image 3...

Image 3 - Statistical Analysis:
Original - Mean: 58.41, Std: 69.66
Best CLAHE - Tile: (4, 4), Clip: 4.0
Best CLAHE - Mean: 73.67, Std: 75.22
Contrast Improvement: 8.0%

# 3. SWAHE DEFINITION (IMPROVED WITH CLIP LIMIT)
#WINDOW_SIZE = 51  # Can adjust this value
WINDOW_SIZE = 51
CLIP_LIMIT = 0.02  # Adjust this value (e.g., 0.01 to 0.05 are common starting points)

def swahe(image, window_size, clip_limit=0.02):
    if window_size % 2 == 0:
        raise ValueError("Window size must be odd.")

    h, w = image.shape
    output_image = np.zeros_like(image)
    pad_size = window_size // 2
    padded_image = np.pad(image, pad_size, mode='reflect')

    print(f"Processing a {h}x{w} image with a {window_size}x{window_size} window and clip_limit={clip_limit}...")

    for y in range(h):
        for x in range(w):
            window = padded_image[y : y + window_size, x : x + window_size]
            center_pixel_value = image[y, x]

            # Calculate histogram
            hist, bins = np.histogram(window.flatten(), bins=256, range=[0, 256])

            # --- Apply Contrast Limiting (CLAHE-like behavior) ---
            num_pixels_in_window = window.size
            max_bin_height = num_pixels_in_window * clip_limit

            # Clip the histogram bins
            excess = 0
            for i in range(len(hist)):
                if hist[i] > max_bin_height:
                    excess += hist[i] - max_bin_height
                    hist[i] = max_bin_height

            # Redistribute the excess
            redistribute_per_bin = excess / 256
            for i in range(len(hist)):
                hist[i] += redistribute_per_bin
            # --- End Contrast Limiting ---

            # Calculate CDF
            cdf = hist.cumsum()

            if cdf[-1] == 0:
                output_image[y, x] = 0
                continue

            # Normalize CDF to 0-255
            cdf_normalized = (cdf * 255 / cdf[-1]).astype(np.uint8)

            # Map the center pixel's value
            output_image[y, x] = cdf_normalized[center_pixel_value]

    print("Processing complete!")
    return output_image

# --- Processing loop for img1, img2, img3 ---
# Images already imported as img1, img2, img3 (see earlier code)
image_objs = [img10]
image_names = ['img10']

for image_obj, image_name in zip(image_objs, image_names):
    if image_obj is None:
        print(f"\nWARNING: Image object '{image_name}' is None. Skipping.")
        continue

    print(f"\nProcessing: {image_name}")

    # If image is RGB, convert to grayscale
    if image_obj.ndim == 3:
        # Handle alpha channel if present
        if image_obj.shape[2] == 4:
            gray_image = cv2.cvtColor((image_obj[..., :3] * 255).astype(np.uint8), cv2.COLOR_RGB2GRAY)
        else:
            gray_image = cv2.cvtColor((image_obj * 255).astype(np.uint8), cv2.COLOR_RGB2GRAY)
    else:
        # Already grayscale, but ensure uint8
        if image_obj.dtype != np.uint8:
            # Assume float in 0-1
            gray_image = (image_obj * 255).astype(np.uint8)
        else:
            gray_image = image_obj

    # Apply SWAHE with the improved function and clip_limit
    swahe_result = swahe(gray_image, window_size=WINDOW_SIZE, clip_limit=CLIP_LIMIT)

    # Display the results
    fig, axes = plt.subplots(1, 2, figsize=(16, 8))

    axes[0].imshow(gray_image, cmap='gray')
    axes[0].set_title('Original (Grayscale)')
    axes[0].axis('off')

    axes[1].imshow(swahe_result, cmap='gray')
    axes[1].set_title(f'SWAHE Result (Window {WINDOW_SIZE}x{WINDOW_SIZE}, Clip {CLIP_LIMIT})')
    axes[1].axis('off')

    fig.suptitle(image_name, fontsize=16)
    plt.show()

Processing: img10
Processing a 256x256 image with a 51x51 window and clip_limit=0.02...
Processing complete!

# ================================================================
# Loading Images (img7, img8, img9)
# ------------------------------------------------
# En esta sección cargamos las tres imágenes seleccionadas
# para el procesamiento con HE y CLAHE.
# ================================================================

# Load images
try:
    img7 = mpimg.imread('data/img7.JPEG')   # Evento deportivo (low-light)
    img8 = mpimg.imread('data/img8.JPEG')   # Flores (contraste y color)
    img9 = mpimg.imread('data/img9.JPG')    # Pared (bajo contraste homogéneo)

    print("Images loaded successfully!")
    print("Image 7 shape:", img7.shape)
    print("Image 8 shape:", img8.shape)
    print("Image 9 shape:", img9.shape)
except FileNotFoundError as e:
    print(f"Error loading images: {e}")
    # Handle gracefully if images are not found
    img7, img8, img9 = None, None, None

# Display the selected images
if img7 is not None and img8 is not None and img9 is not None:
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))

    axes[0].imshow(img7)
    axes[0].set_title('Image 7 — Low Light')
    axes[0].axis('off')

    axes[1].imshow(img8)
    axes[1].set_title('Image 8 — Flowers')
    axes[1].axis('off')

    axes[2].imshow(img9)
    axes[2].set_title('Image 9 — Wall')
    axes[2].axis('off')

    plt.tight_layout()
    plt.show()

Images loaded successfully!
Image 7 shape: (3024, 3024, 3)
Image 8 shape: (4032, 3024, 3)
Image 9 shape: (1826, 2014, 3)

# ================================================================
# — Procesamiento de imágenes con HE y CLAHE (comparación)
# ---------------------------------------------------------------
# En esta sección se implementa la comparación entre:
#   1. La imagen original en escala de grises.
#   2. Histogram Equalization (HE) global.
#   3. CLAHE con configuración por defecto.
#   4. CLAHE con configuración alternativa (clip limit mayor y bloques más pequeños).
#
# El objetivo es observar cómo varía la distribución del histograma
# y los indicadores cuantitativos (desviación estándar y entropía),
# mostrando en una misma figura la imagen resultante y su histograma.
# ================================================================

# ------------------------------
# Funciones auxiliares
# ------------------------------

def to_uint8(img):
    """
    Convierte la imagen a formato uint8 [0,255].
    Si la imagen se encuentra en flotantes [0,1], realiza la conversión.
    Esto asegura compatibilidad con OpenCV en las operaciones posteriores.
    """
    return (img * 255).astype(np.uint8) if img.dtype.kind == "f" else img.astype(np.uint8)

def image_entropy(img_uint8):
    """
    Calcula la entropía del histograma de la imagen.
    La entropía mide el grado de dispersión de los niveles de gris,
    reflejando la cantidad de información contenida en la imagen.
    Valores más altos implican mayor diversidad tonal.
    """
    hist = cv2.calcHist([img_uint8], [0], None, [256], [0, 256]).ravel()
    p = hist / (hist.sum() + 1e-12)   # normalización a distribución de probabilidad
    p = p[p > 0]                      # se eliminan ceros para evitar log indefinidos
    return float(-(p * np.log(p)).sum())

def show_hist(ax, img, title):
    """
    Grafica el histograma de una imagen en escala de grises.
    Se utiliza para visualizar la redistribución de intensidades
    después de aplicar HE o CLAHE.
    """
    ax.hist(img.ravel(), bins=256, range=(0, 255))
    ax.set_title(title)
    ax.set_xlabel("Gray level")
    ax.set_ylabel("Frequency")
    ax.grid(alpha=0.3)

# ------------------------------
# Conversión a escala de grises
# ------------------------------
# Las técnicas de HE y CLAHE operan sobre imágenes en un solo canal.
# Se convierte cada imagen a escala de grises para aplicar las transformaciones.
# ------------------------------
assert img7 is not None and img8 is not None and img9 is not None, "Las imágenes deben cargarse primero."

imgs_rgb  = [img7, img8, img9]
titles    = ["Image 7 — Low Light", "Image 8 — Flowers", "Image 9 — Wall"]
imgs_gray = [cv2.cvtColor(to_uint8(im), cv2.COLOR_RGB2GRAY) for im in imgs_rgb]

# ------------------------------
# Configuración de CLAHE
# ------------------------------
# - Configuración por defecto: clipLimit=2.0, grid=(8x8).
# - Variante: clipLimit=4.0, grid=(4x4).
# Estas configuraciones permiten comparar cómo la limitación de contraste
# y el tamaño de las teselas afectan la mejora de la imagen.
# ------------------------------
clahe_cfg_default = {"clip": 2.0, "grid": (8, 8)}
clahe_cfg_variant = {"clip": 4.0, "grid": (4, 4)}

# ------------------------------
# Procesamiento principal
# ------------------------------
# Para cada imagen:
#   1. Se calculan métricas del original (desviación estándar y entropía).
#   2. Se aplica HE (global).
#   3. Se aplica CLAHE en dos configuraciones.
#   4. Se muestran las imágenes y sus histogramas.
#   5. Se almacenan las métricas en una tabla comparativa.
# ------------------------------
summary_rows = []

for gimg, title in zip(imgs_gray, titles):

    # --- Imagen original ---
    orig_std = float(np.std(gimg))
    orig_ent = image_entropy(gimg)

    # --- Histogram Equalization (HE) global ---
    he_img  = cv2.equalizeHist(gimg)
    he_std  = float(np.std(he_img))
    he_ent  = image_entropy(he_img)

    # --- CLAHE (configuración por defecto) ---
    clahe_d = cv2.createCLAHE(clipLimit=clahe_cfg_default["clip"],
                              tileGridSize=clahe_cfg_default["grid"]).apply(gimg)
    d_std   = float(np.std(clahe_d))
    d_ent   = image_entropy(clahe_d)

    # --- CLAHE (configuración variante) ---
    clahe_v = cv2.createCLAHE(clipLimit=clahe_cfg_variant["clip"],
                              tileGridSize=clahe_cfg_variant["grid"]).apply(gimg)
    v_std   = float(np.std(clahe_v))
    v_ent   = image_entropy(clahe_v)

    # --- Visualización comparativa ---
    # Se generan figuras con 2 filas × 4 columnas:
    #   Fila 1: imágenes (Original, HE, CLAHE default, CLAHE variant).
    #   Fila 2: histogramas correspondientes.
    fig, axes = plt.subplots(2, 4, figsize=(18, 7))
    fig.suptitle(f"HE vs CLAHE — {title}", fontsize=14, fontweight="bold")

    # Fila 1: imágenes
    axes[0, 0].imshow(gimg, cmap="gray");    axes[0, 0].set_title("Original"); axes[0, 0].axis("off")
    axes[0, 1].imshow(he_img, cmap="gray");  axes[0, 1].set_title("HE (Global)"); axes[0, 1].axis("off")
    axes[0, 2].imshow(clahe_d, cmap="gray"); axes[0, 2].set_title(f"CLAHE default\nclip={clahe_cfg_default['clip']}, grid={clahe_cfg_default['grid']}"); axes[0, 2].axis("off")
    axes[0, 3].imshow(clahe_v, cmap="gray"); axes[0, 3].set_title(f"CLAHE variant\nclip={clahe_cfg_variant['clip']}, grid={clahe_cfg_variant['grid']}"); axes[0, 3].axis("off")

    # Fila 2: histogramas
    show_hist(axes[1, 0], gimg,   f"Original\nstd={orig_std:.2f}  ent={orig_ent:.3f}")
    show_hist(axes[1, 1], he_img, f"HE\nstd={he_std:.2f}  ent={he_ent:.3f}")
    show_hist(axes[1, 2], clahe_d,f"CLAHE default\nstd={d_std:.2f}  ent={d_ent:.3f}")
    show_hist(axes[1, 3], clahe_v,f"CLAHE variant\nstd={v_std:.2f}  ent={v_ent:.3f}")

    plt.tight_layout()
    plt.show()

    # --- Registro de resultados para la tabla comparativa ---
    summary_rows += [
        (title, "Original",       orig_std, orig_ent, "—", "—"),
        (title, "HE (global)",    he_std,   he_ent,   "—", "—"),
        (title, "CLAHE default",  d_std,    d_ent,    f"clip={clahe_cfg_default['clip']}",  f"grid={clahe_cfg_default['grid']}"),
        (title, "CLAHE variant",  v_std,    v_ent,    f"clip={clahe_cfg_variant['clip']}",  f"grid={clahe_cfg_variant['grid']}"),
    ]

# ------------------------------
# Tabla resumen de resultados
# ------------------------------
# Se presenta un cuadro con:
#   - Nombre de la imagen.
#   - Método aplicado.
#   - Desviación estándar (std).
#   - Entropía (ent).
#   - Parámetros de CLAHE (si aplican).
# ------------------------------
print("\n=== Comparison Summary (std / entropy) ===")
print(f"{'Image':<22} | {'Method':<15} | {'std':>8} | {'entropy':>8} | {'clip':<10} | {'grid':<10}")
print("-"*80)
for row in summary_rows:
    img_name, method, s, e, clip, grid = row
    print(f"{img_name:<22} | {method:<15} | {s:8.2f} | {e:8.3f} | {clip:<10} | {grid:<10}")

=== Comparison Summary (std / entropy) ===
Image                  | Method          |      std |  entropy | clip       | grid      
--------------------------------------------------------------------------------
Image 7 — Low Light    | Original        |    23.15 |    2.373 | —          | —         
Image 7 — Low Light    | HE (global)     |    78.18 |    2.244 | —          | —         
Image 7 — Low Light    | CLAHE default   |    33.46 |    2.922 | clip=2.0   | grid=(8, 8)
Image 7 — Low Light    | CLAHE variant   |    34.97 |    2.919 | clip=4.0   | grid=(4, 4)
Image 8 — Flowers      | Original        |    79.92 |    5.440 | —          | —         
Image 8 — Flowers      | HE (global)     |    73.65 |    5.277 | —          | —         
Image 8 — Flowers      | CLAHE default   |    74.36 |    5.530 | clip=2.0   | grid=(8, 8)
Image 8 — Flowers      | CLAHE variant   |    72.76 |    5.532 | clip=4.0   | grid=(4, 4)
Image 9 — Wall         | Original        |     8.56 |    3.519 | —          | —         
Image 9 — Wall         | HE (global)     |    74.24 |    3.487 | —          | —         
Image 9 — Wall         | CLAHE default   |    12.50 |    3.919 | clip=2.0   | grid=(8, 8)
Image 9 — Wall         | CLAHE variant   |    19.15 |    4.341 | clip=4.0   | grid=(4, 4)

2.5 Google Colab - Algoritmos de mejoramiento de imágenes basado por pixeles¶

Computer Vision for Images and Video (TC4033 - Group 10)¶

Importing Libraries ¶

Loading Images ¶

Exercise 1¶

-------------------------------¶

Tile-Based Histogram Equalization (CLAHE)¶

Implementation and Parameter Testing¶

How to Improve the Contrast Between Blocks¶

CLAHE Best Practices and Usage Guidelines¶

When to Use CLAHE:¶

Parameter Selection Guide:¶

Clip Limit (Contrast Limiting):¶

Tile Grid Size:¶

Best Practices:¶

Exercise 2¶

-------------------------------¶

Exercise 3¶

-------------------------------¶

Objective¶

Description of the Method¶

Image Processing with CLAHE and HE¶

Results¶

Bibliography¶